home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / escalant / escala21.lha / escalante2.1 / src / editor / Escalante.C < prev    next >
C/C++ Source or Header  |  1993-07-15  |  18KB  |  823 lines
  1. //
  2. //    Copyright (C) 1993  Jeff McWhirter
  3. //
  4.  
  5. //$EscalanteDocument$
  6. #include    "Escalante.h"
  7. #include    "ET++.h"
  8. #include    "Env.h"
  9.  
  10. #include     "LineItem.h"
  11. #include    "Filler.h"
  12. #include    "MenuBar.h"
  13. #include    "ObjArray.h"
  14. #include    "ObjList.h"
  15. #include    "CollView.h"
  16. #include    "FileDialog.h"
  17. #include    "CollView.h"
  18. #include    "Look.h"
  19. #include    "Scroller.h"
  20. #include    "Clipper.h"
  21. #include    "WindowSystem.h"
  22. #include    "Token.h"
  23. #include    "WindowPort.h"
  24. #include    "Buttons.h"
  25. #include    "Scroller.h"
  26. #include    "Zoomer.h"
  27. #include    "PrintManager.h" 
  28. #include    "Form.h"
  29. #include    "BorderItems.h"
  30. #include    "CommandProcessor.h"
  31. #include    "SizeableExp.h"
  32.  
  33.  
  34.  
  35. #include    "VObjGfx.h"
  36. #include    "EscalanteView.h"
  37.  
  38.  
  39. int    gPaletteDocumentRows;
  40. int    gPaletteDocumentCols;
  41. bool     gPaletteDocumentSquare;
  42.  
  43. char *    cDocTypeBasic=     "ESCALANTE";
  44. char *     cDocTypeSgVgs = "SGVGS";
  45. char *     cDocTypeSgVg =     "SGVG";
  46. char *     cDocTypeVg =     "VG";
  47. char *     cDocTypeVgs =     "VGS";
  48.  
  49. float    gObsViewZoom = 0.40;
  50.  
  51.  
  52. EscalanteManager * gEscalanteManager =0;
  53.  
  54.  
  55.  
  56. //---- EscalanteDocument ----------------------------------------------------------
  57.  
  58. NewMetaImpl(EscalanteDocument,Document, (TP(vgraph), TP(views),0));
  59.  
  60.  
  61. EscalanteDocument::~EscalanteDocument(){
  62.     if(views)
  63.         views->FreeAll();
  64.     SafeDelete(views);
  65. }
  66.  
  67. bool  EscalanteDocument::Close(){
  68. bool result = Manager::Close();
  69. if(views && result){
  70.     BaseEscalanteView * v;
  71.     Iter next(views);
  72.     while(v = (BaseEscalanteView*)next())
  73.         v->Send(cViewClosed,0,(void*)v);    
  74. }
  75. return result;
  76.  
  77.  
  78. /**
  79. bool result =  EscalanteDocument_BASE::Close();
  80. if(views && result){
  81.     BaseEscalanteView * v;
  82.     Iter next(views);
  83.     while(v = (BaseEscalanteView*)next())
  84.         v->NewGraph(0,0,FALSE);
  85. }
  86. return result;
  87. **/
  88. }
  89.  
  90.  
  91.  
  92.  
  93. void  EscalanteDocument::MyClose(){
  94. if(views){
  95.     BaseEscalanteView * v;
  96.     Iter next(views);
  97.     while(v = (BaseEscalanteView*)next())
  98.         v->NewGraph(0,FALSE);
  99. }
  100. }
  101.  
  102.  
  103. EscalanteDocument::EscalanteDocument(VGraphElement * ve) : Document(cDocTypeBasic){
  104.     vgraph = ve;
  105.     views = new ObjList();
  106.     SetOnDismiss(eMgrClose);
  107. }
  108.  
  109.  
  110. void EscalanteDocument::DoSetupMenu(Menu* m ){
  111.  
  112. register EscalanteView * dv; 
  113. Iter next(views);
  114. int id = m->GetId();
  115.  
  116.  
  117. if(id == cALLDV  || 
  118.     id ==     cDVMENU  ||
  119.     id ==     cDELMENU|| 
  120.     id ==     cPICKMENU || 
  121.     id ==     cESCALANTE_EDITMENU ){
  122.         while(dv = (EscalanteView*)next())
  123.             if( dv != gFirstHandler)
  124.                 dv->DoSetupMenu(m);
  125.     }
  126.  
  127. m->EnableItem(cQUIT);
  128. Document::DoSetupMenu(m);
  129. }
  130.  
  131. MenuBar *EscalanteDocument::DoMakeMenuBar()
  132. {
  133. if(!Env::GetValue("EscalanteDocument.MakeMenuBar",1)) 
  134.     return 0;
  135.  
  136. MenuBar *mb= new MenuBar();
  137. if(Env::GetValue("EscalanteDocument.MakeHelpMenu",1))
  138.     mb->AddMenu(MakeMenu(cHELPMENU));
  139. if(Env::GetValue("EscalanteDocument.MakeFileMenu",1))
  140.     mb->AddMenu(MakeMenu(cFILEMENU));
  141.  
  142.  
  143. Menu * helpm = mb->FindMenu(cHELPMENU);
  144. if(helpm){
  145.     helpm->RemoveItem(cHELP);
  146.     helpm->AppendItem("About View",ABOUTVIEW);
  147.     helpm->AppendItem("About Current Mode",ABOUTCURRENTMODE);
  148.     helpm->AppendItem("About A Mode",ABOUTMODE);
  149.     helpm->AppendItem("About Element",ABOUTELT);
  150.     helpm->AppendItem("Misc.",    ABOUTMISC);
  151. }
  152.  
  153. Menu * filem = mb->FindMenu(cFILEMENU);
  154. if(filem){
  155.     filem->RemoveItem(cNEW);
  156.     filem->RemoveItem(cOPEN);
  157.     filem->RemoveItem(cREVERT);
  158.  
  159. }
  160. Menu * m;
  161.  
  162.  
  163. if(Env::GetValue("EscalanteDocument.MakeViewMenu",1)){
  164.     m = EscalanteView::MakeMenu(cALLDV);
  165.     if(m){
  166.         m->SetName("View");
  167.         mb->AddMenu(m);
  168.     }
  169. }
  170.  
  171. if(Env::GetValue("EscalanteDocument.MakeDeleteMenu",1) && ! gDeleteInEdit){
  172.     m = EscalanteView::MakeMenu(cDELMENU);
  173.     if(m){
  174.         m->SetName("Delete");
  175.         mb->AddMenu(m);
  176.     }
  177. }
  178.  
  179.  
  180. if(Env::GetValue("EscalanteDocument.MakePickMenu",1) && ! gPickInEdit){
  181.     m = EscalanteView::MakeMenu(cPICKMENU);
  182.     if(m){
  183.         m->SetName("Pick");
  184.         mb->AddMenu(m);
  185.     }
  186. }
  187.  
  188.  
  189. if(Env::GetValue("EscalanteDocument.MakeEditMenu",1)){
  190.     m = EscalanteView::MakeMenu(cESCALANTE_EDITMENU);
  191.     if(m){
  192.         m->SetName("Edit");
  193.         mb->AddMenu(m);
  194.     }
  195.  
  196. }
  197.  
  198. return mb;
  199. }
  200.  
  201.  
  202.  
  203.  
  204. EscalanteView * EscalanteDocument::MakeEscalanteView(int id,Point p, VGraphElement *vg){
  205. return  new EscalanteView(id,this,p,vg);
  206. }
  207.  
  208.  
  209.  
  210.  
  211.  
  212.  
  213.  
  214. VObject *EscalanteDocument::DoMakeContent(){
  215.  
  216. if(!vgraph)return 0;
  217. EscalanteView *  dv=0;
  218. ScaledObserverView * ov=0;
  219.  
  220.  
  221.  
  222.  
  223.  
  224. gPickInEdit = Env::GetValue("EscalanteView.PickMenuInEditMenu", 0);
  225. gDeleteInEdit = Env::GetValue("EscalanteView.DeleteMenuInEditMenu", 0);
  226.  
  227.  
  228. gDoKeyCommands = Env::GetValue("EscalanteView.DoKeyCommands", 0);
  229. gDoFromTlAttrMap = Env::GetValue("Escalante.DoFromTlAttrMap", 1);
  230. gDoFromHdAttrMap = Env::GetValue("Escalante.DoFromHdAttrMap", 1);
  231. gDoFromRelAttrMap = Env::GetValue("Escalante.DoFromRelAttrMap", 1);
  232.  
  233.  
  234.  
  235. bool makeObserver =        Env::GetValue("EscalanteDocument.MakeObserver",FALSE);
  236. bool withPalette =    Env::GetValue("EscalanteDocument.MakeObserverWithPalette",FALSE);
  237. bool sepObs =        Env::GetValue("EscalanteDocument.MakeSeparateObserver",0);
  238. bool separatePalette =    Env::GetValue("EscalanteView.MakeSeparatePalette",FALSE);
  239.  
  240.  
  241.  
  242. cIdEscalanteView += cIdEscalanteViewInc;
  243. dv= MakeEscalanteView(cIdEscalanteView,Point(5000),vgraph);
  244. if(dv){
  245.     dv->InitView();
  246.     if((separatePalette || dv->MakeSeparatePalette())&& 
  247.         !dv->DoNotMakeExtraPalette())
  248.             gEscalanteManager->AddManager(new  PaletteDocument(dv));
  249.  
  250.     gPrintManager->AddObserver(dv);
  251.     SetFirstHandler(dv);
  252.     AddEscalanteView(dv);
  253.     vgraph->AddView(dv);
  254.     if(makeObserver && !dv->DoNotMakeObserverView()) {
  255.         cIdEscalanteView += cIdEscalanteViewInc;
  256.         ov=new ScaledObserverView(dv,cIdEscalanteView,this,Point(2000),vgraph,withPalette);
  257.         ov->InitView();
  258.         AddEscalanteView(ov);
  259.         vgraph->AddView(ov);
  260.     }
  261.  
  262.  
  263.     if(sepObs && !dv->DoNotMakeObserverView()) 
  264.         gEscalanteManager->AddManager(new ObserverDocument(vgraph,dv));
  265.  
  266. }
  267.  
  268. VObject * viewVop, * obsVop;
  269.  
  270.  
  271. if(dv && ov){
  272.     viewVop = dv->GetView();
  273.     obsVop =  ov->GetView();
  274.     ov->InitObserver(gObsViewZoom);
  275.     LineItem*line = new LineItem(TRUE,2);
  276.     line->SetFlag(eVObjVFixed,TRUE);
  277.     line->SetFlag(eVObjHFixed,FALSE);
  278.  
  279.     Filler * filler  =new Filler(Point(0,2));
  280.     filler->SetFlag(eVObjVFixed,TRUE);
  281.     filler->SetFlag(eVObjHFixed,FALSE);
  282.     Filler * filler2  =new Filler(Point(0,2));
  283.     filler2->SetFlag(eVObjVFixed,TRUE);
  284.     filler2->SetFlag(eVObjHFixed,FALSE);
  285.  
  286.     return new Expander(0,eVert,gPoint0,viewVop,filler,line,filler2,obsVop,0);
  287. }
  288. else if(dv) return new Expander(0,eVert,gPoint0,dv->GetView(),0);
  289. return 0;
  290. }
  291.  
  292.  
  293.  
  294. VObject *ObserverDocument::DoMakeContent(){
  295. ScaledObserverView * sov=0;
  296. cIdEscalanteView += cIdEscalanteViewInc;
  297. sov=new ScaledObserverView(theview,cIdEscalanteView,this,Point(2000),vgraph,FALSE);
  298. sov->InitObserver(gObsViewZoom);
  299. sov->InitView();
  300. gPrintManager->AddObserver(sov);
  301. SetFirstHandler(sov);
  302. AddEscalanteView(sov);
  303. vgraph->AddView(sov);
  304. return new Expander(0,eVert,gPoint0,sov->GetView(),0);
  305. }
  306.  
  307.  
  308.  
  309.  
  310.  
  311.  
  312. void EscalanteDocument::Control(int id, int part, void *val)
  313. {
  314. //bool sent = FALSE;
  315. //Iter next(views);
  316. //BaseEscalanteView * v;
  317. //while((v = (BaseEscalanteView*)next()) && !sent)
  318. //     sent =     v->Interested(id,part,val);        
  319. //if(!sent)      
  320.     Document::Control(id, part, val);
  321. }
  322.  
  323.  
  324.  
  325.  
  326.  
  327. Command *EscalanteDocument::DoMenuCommand(int cmd){
  328. //
  329. //Loop through each view in this document and see if it is 
  330. //interested in this menu command 
  331. //
  332.  
  333. Iter next(views);
  334. BaseEscalanteView * v;
  335. Command * c; 
  336. while((v = (BaseEscalanteView*)next())){
  337.     c= v->Interested(cmd); 
  338.     if(c !=   gNoChanges)
  339.         return c;
  340. }
  341.  
  342.  
  343. //
  344. //Catch any save/read/etc commands  and pass them along to the 
  345. //EscalanteManager  to handle
  346. //
  347.  
  348. switch(cmd) {
  349.     case cSAVE:     
  350.     case cSAVEAS:   
  351.     case cLOAD:     
  352.     case cREVERT:   
  353.     return Manager::DoMenuCommand(cmd);
  354.     }
  355.  
  356.  
  357. return EscalanteDocument_BASE::DoMenuCommand(cmd);
  358. }
  359.  
  360.  
  361.  
  362.  
  363. NewMetaImpl(EscalanteManager,EscalanteManager_BASE,(TP(vgraphs),TP(sgraph),0));
  364.  
  365.  
  366.  
  367. EscalanteDocument *  EscalanteManager::NewEscalanteDocument(VGraphElement *v){
  368. EscalanteDocument * gd;
  369. if(vgraphs && v && ! vgraphs->Contains(v))  
  370.     vgraphs->Add(v);
  371. gd = MakeEscalanteDocument(v);
  372. if(gd)    AddManager(gd);
  373. return gd;
  374. }
  375.  
  376.  
  377. EscalanteDocument * EscalanteManager::MakeEscalanteDocument(VGraphElement *vg){return new EscalanteDocument(vg);}
  378.  
  379.  
  380.  
  381. bool EscalanteManager::Close(){
  382. //Modified(FALSE);
  383. //gGraphModified = FALSE;
  384.  
  385. if(SavedChanges()) 
  386.     return Manager::Close();
  387. return FALSE;
  388. }
  389.  
  390.  
  391. bool EscalanteManager::Modified(){
  392.     return ((TestFlag(eEscalanteManModified)||gGraphModified)? TRUE:EscalanteManager_BASE::Modified());
  393. }
  394.  
  395.  
  396. VObject *EscalanteManager::DoMakeContent(){
  397. if(!vgraphs)return 0;
  398. Iter next(vgraphs);
  399. VGraphElement * vg;
  400. EscalanteDocument * gd;
  401. while(vg = (VGraphElement*)next()) {
  402.     gd = MakeEscalanteDocument(vg);
  403.     if(gd)    AddManager(gd);
  404. }
  405. return 0;
  406. }
  407.  
  408.  
  409.  
  410.  
  411.  
  412. bool EscalanteManager::DoRead(IStream&i, Data *data){
  413. MakeColorList();
  414.  
  415. if(!EscalanteManager_BASE::DoRead(i,data)) return FALSE;
  416.  
  417. bool hadOne = FALSE;
  418. Iter next(MakeIterator());
  419. class Manager * m;
  420. while(m = (class Manager*) next()){
  421.     hadOne = TRUE;
  422.     RemoveManager(m);
  423. //??? Don't think I have to do this here     ???
  424.     //SafeDelete(m);
  425. }
  426. sgraph=0; vgraphs=0;
  427.  
  428. if(data->Type() == cDocTypeSgVgs){
  429.     if(gVSetIO)    ReadInVSet(i);
  430.  
  431.  
  432. #ifdef USE_STRUCTURAL
  433.     if(gSSetIO)    ReadInSSet(i);
  434. #endif
  435.  
  436.     i  >> sgraph;
  437.     i  >> vgraphs;
  438.  
  439.     {
  440.         GetVGraphElementSet()->ForEach(GraphObject,InitAfterReading)();
  441.     }
  442. #ifdef USE_STRUCTURAL
  443.     {
  444.         GetSGraphElementSet()->ForEach(GraphObject,InitAfterReading)();
  445.     }
  446. #endif
  447.  
  448. }
  449. else if(data->Type() == cDocTypeSgVg){
  450.     if(gVSetIO)    ReadInVSet(i);
  451.  
  452.  
  453. #ifdef USE_STRUCTURAL
  454.     if(gSSetIO)    ReadInSSet(i);
  455. #endif
  456.  
  457.  
  458.     {
  459.         GetVGraphElementSet()->ForEach(GraphObject,InitAfterReading)();
  460.     }
  461.  
  462. #ifdef USE_STRUCTURAL
  463.     {
  464.         GetSGraphElementSet()->ForEach(GraphObject,InitAfterReading)();
  465.     }
  466. #endif
  467.  
  468.     VGraphElement * tmpVg =0;
  469.     sgraph =0;
  470.     i  >> sgraph;  
  471.     i >> tmpVg;
  472.     vgraphs = new ObjList();
  473.     vgraphs->Add(tmpVg);
  474. }
  475.  
  476. else if(data->Type() == cDocTypeVg){
  477.     if(gVSetIO)    ReadInVSet(i);
  478.     {
  479.         GetVGraphElementSet()->ForEach(GraphObject,InitAfterReading)();
  480.     }
  481.     sgraph =0;
  482.  
  483.     VGraphElement * tmpVg =0;
  484.     i   >>  tmpVg;
  485.     vgraphs = new ObjList();
  486.     vgraphs->Add(tmpVg);
  487. }
  488. else if(data->Type() == cDocTypeVgs){
  489.     if(gVSetIO)    ReadInVSet(i);
  490.     i  >>  vgraphs;
  491.     sgraph =0;
  492.     {
  493.         GetVGraphElementSet()->ForEach(GraphObject,InitAfterReading)();
  494.     }
  495. }
  496.  
  497.  
  498.  
  499. if(!vgraphs)   {
  500.     if(hadOne) Show();
  501.     return     FALSE;
  502. }
  503. Show();
  504. return TRUE;
  505. }
  506.  
  507.  
  508. bool EscalanteManager::DoWrite(OStream&o, Data *){
  509. Iter next(MakeIterator());
  510. class Manager * m;
  511. while(m = (class Manager*) next())
  512.     m->GetCmdP()->Finish();
  513.  
  514.  
  515. gGraphModified = FALSE;
  516. Modified(FALSE);
  517. o << cMagic SP << cDocTypeSgVgs SP << gApplication->ProgramName() NL;
  518. if(gVSetIO)    WriteOutVSet(o);
  519.  
  520.  
  521. #ifdef USE_STRUCTURAL
  522. if(gSSetIO)    WriteOutSSet(o);
  523. #endif
  524.  
  525. o  << sgraph SP  <<  vgraphs SP ;
  526.  
  527.  
  528. return TRUE;
  529. }
  530.  
  531.  
  532.  
  533. NewMetaImpl(Escalante,Escalante_BASE, (TP(vgs), TP(sg),0));
  534.  
  535.  
  536. Escalante::Escalante(int argc, char **argv) : Application(argc, argv, cDocTypeBasic){
  537. sg = 0;
  538. vgs = 0;
  539. version = "\nEscalante Version 2.1  - 7/14/93, \251 Jeff McWhirter, jeffm@cs.colorado.edu";
  540.  
  541.  
  542.  
  543. gGridSize = Point(10,10);
  544. gGridSize.y= Env::GetValue("EscalanteView.GridSizeY",10);
  545. gGridSize.x= Env::GetValue("EscalanteView.GridSizeX",10);
  546.  
  547.  
  548. gViewSize.x =  Env::GetValue("EscalanteView.ViewSizeX",300);
  549. gViewSize.y =  Env::GetValue("EscalanteView.ViewSizeY",200);
  550.  
  551. gObsViewZoom=        (float)Env::GetValue("ObserverView.ZoomFactor",40)/100;
  552.  
  553.  
  554.  
  555.  
  556.  
  557. gNoRepeatAdd=        Env::GetValue("EscalanteView.NoRepeatAdd",0);
  558. gPaletteDocumentSquare= Env::GetValue("PaletteDocument.MakeSquare",0);
  559. gPaletteDocumentRows =    Env::GetValue("PaletteDocument.PaletteRows",0);
  560. gPaletteDocumentCols =    Env::GetValue("PaletteDocument.PaletteCols",1);
  561. gGravity =        Env::GetValue("EscalanteView.Gravity",40);
  562. gRubberBand =        Env::GetValue("EscalanteView.RubberBand",1);
  563. gNameInPalette =    Env::GetValue("EscalanteView.DrawNameInPalette",1);
  564. gBitmapInPalette =    Env::GetValue("EscalanteView.DrawBitmapInPalette",1);
  565. gPaletteGap.x    =    Env::GetValue("EscalanteView.PaletteGap",2);
  566. gPaletteGap.y=        Env::GetValue("EscalanteView.PaletteGap",2);
  567. gPaletteItemSize.x =    Env::GetValue("EscalanteView.PaletteItemSizeX",16);
  568. gPaletteItemSize.y =    Env::GetValue("EscalanteView.PaletteItemSizeY",16);
  569. gMakePalette=        Env::GetValue("EscalanteView.MakePalette",1);  
  570. gPaletteRows =        Env::GetValue("EscalanteView.PaletteRows",0);
  571. gPaletteCols =        Env::GetValue("EscalanteView.PaletteCols",1);
  572. gPaletteThreshold =    Env::GetValue("EscalanteView.PaletteThreshold",0);
  573. gPaletteOrientation =    Env::GetValue("EscalanteView.PaletteOrientation",0);
  574.  
  575.  
  576. gDoBell  =        Env::GetValue("EscalanteView.DoBell",0);
  577. gTransNewGraph =    Env::GetValue("EscalanteView.TransNewGraph",1);
  578. gTransNorth =        Env::GetValue("EscalanteView.TransNorth",1);
  579.  
  580.  
  581. }
  582.  
  583.  
  584. Command *Escalante::DoMenuCommand(int cmd){
  585. if(cmd == cABOUT){
  586.     ShowAlert(eAlertSun,"%s %s", ProgramName(),version);
  587.     return gNoChanges;
  588. }
  589. return  Escalante_BASE::DoMenuCommand(cmd);
  590. }
  591.  
  592. Escalante::~Escalante(){}
  593.  
  594. bool Escalante::CanOpen(Data *data){
  595. if(data->Type() == cDocTypeSgVgs || 
  596.     data->Type() == cDocTypeSgVg ||
  597.     data->Type() == cDocTypeVg ||
  598.     data->Type() == cDocTypeVgs) return TRUE;
  599. else return Escalante_BASE::CanOpen(data);
  600. }
  601.  
  602.  
  603. EscalanteManager * Escalante::MakeEscalanteManager(SGraphElement * sg,ObjList * vgs)
  604. {
  605. return new EscalanteManager(sg,vgs);
  606. }
  607.  
  608.  
  609. Manager *Escalante::DoMakeManager(Symbol type){
  610.     sg =0;
  611.     vgs =0;
  612.     if(type == cDocTypeBasic)MakeGraph(sg,vgs);
  613.     gEscalanteManager =       MakeEscalanteManager(sg,vgs);
  614.     return gEscalanteManager;
  615. }
  616.  
  617.  
  618.  
  619.  
  620.  
  621.  
  622.  
  623.  
  624. VObject *PaletteDocument::DoMakeContent(){
  625.  
  626. int rows  = gPaletteDocumentRows;
  627. int cols  = gPaletteDocumentCols;
  628.  
  629. int orient= Env::GetValue("PaletteDocument.PaletteOrientation",0);
  630.  
  631.  
  632. int    dopalette =    Env::GetValue("EscalanteView.DoPaletteScroller",1);
  633.  
  634.  
  635.  
  636. palette= new CollectionView(this, tools, eCVDefault,rows,cols);
  637. palette->SetGap(gPaletteGap);
  638. palette->SetId(cIdPalette);
  639.  
  640.  
  641.  
  642.  
  643. Point        min(30,30);
  644.  
  645. if(dopalette){
  646.      paletteWrapper =new Scroller(palette,min,cIdNone,(ScrollDir)(eScrollNone));
  647.  
  648.     Ink * bg = gLook->GetBackgroundColor();
  649.     ((Scroller*)paletteWrapper)->SetBgInk(bg);
  650. }
  651. else 
  652.     paletteWrapper = new Clipper(palette,
  653.                     min,
  654.                     cIdNone,
  655.                     gLook->GetBackgroundColor());
  656.  
  657.  
  658. if(gPaletteDocumentSquare){
  659.     paletteWrapper->SetFlag(eVObjHFixed,TRUE);
  660.     paletteWrapper->SetFlag(eVObjVFixed,TRUE);
  661. }
  662. else {
  663.     if(orient == PALETTE_LEFT || orient == PALETTE_RIGHT)
  664.         paletteWrapper->SetFlag(eVObjHFixed,TRUE);
  665.     else
  666.         paletteWrapper->SetFlag(eVObjVFixed,TRUE);
  667. }
  668.  
  669. MakeToolList();
  670. return (VObject*)new Matte(Point(2,2),paletteWrapper);
  671. }
  672.  
  673.  
  674. PaletteDocument::PaletteDocument(EscalanteView *theview): Document(cDocTypeBasic){
  675. Manager::SetName("Palette");
  676. view = theview;
  677. if(view) view->AddObserver(this);
  678. tools = new ObjList();
  679. palette = 0;
  680. }
  681.  
  682.  
  683.  
  684. void PaletteDocument::DoObserve(int id, int part, void *d , Object *op){
  685. if(part == cPartSenderDied && op == view) view = 0;
  686. else if( id == cPaletteChanged && op == view){
  687.     MakeToolList();
  688. }
  689. else PaletteDocument_BASE::DoObserve(id, part,d , op);
  690. }
  691.  
  692.  
  693.  
  694. void PaletteDocument::Control(int id, int part, void *val){
  695. if(!view){
  696.     Document::Control(id,part,val);
  697.     return;
  698. }
  699. if (palette && 
  700.     id == cIdPalette && 
  701.     (part == cPartCollSelect || part == cPartCollDoubleSelect)){
  702.         Point  ix= palette->GetSelection().origin;
  703.         VObject * vop = palette->GetItem(ix.x,ix.y);
  704.         if(!vop) return;
  705.         VObject* inner =0;
  706. //
  707. //Is this a PaletteItem with its element set?
  708. //
  709.         if(vop->IsKindOf(Button)) {
  710.             inner = ((Button*)vop)->At(0);
  711.             if(inner && inner ->IsKindOf(PaletteItem)) {
  712.                 VGraphElement * vp = ((PaletteItem*)inner)->elt;
  713.                 if(vp){
  714.                     view->SetTool(vp);
  715.                     return;
  716.                 }
  717.             }
  718.         }
  719. //
  720. //If not an element then call SetAction with the id of the VObject
  721. //
  722.         view->SetAction((Actions)vop->GetId(),(void*)vop);
  723. }
  724. else Document::Control(id,part,val);
  725. }
  726.  
  727.  
  728.  
  729.  
  730. void PaletteDocument::MakeToolList(){
  731.     VGraphElement * elt;
  732.     if(!view) return;
  733.     ObjList * graphProtos = view->GetProtoList();
  734.     ObjList dummy2;
  735.     if(!graphProtos) graphProtos =  &dummy2;
  736.  
  737. //
  738. //set the palette list to this dummy so that when we are yanking and 
  739. //putting things into the tools list it doesn't affect the palette
  740. //
  741.     ObjList dummy;
  742.     palette->SetCollection(&dummy,FALSE);
  743.  
  744. //
  745. //Put the unused PaletteItems into the extra list so we don't have to keep
  746. //deleting and making new
  747. // 
  748.     PaletteItem * ei;
  749.     Button * button;
  750.     VObject * tmpo;
  751.  
  752.     while(tmpo = (VObject*)tools->RemoveLast())
  753.         gExtraPaletteItems.Add(tmpo);
  754.  
  755.     Iter next(graphProtos);
  756.     Point   maxp(20,10);
  757. //    Metric m;
  758.     while (elt= (VGraphElement*) next())
  759.         if(elt->IsKindOf(VGraphElement)){
  760.             if(elt->ShowInPalette()){
  761.                 tmpo  = (VObject*)gExtraPaletteItems.RemoveLast();
  762.                 ei =0;
  763.                 button = 0;
  764.                 if(tmpo){
  765.                     if(tmpo->IsKindOf(PaletteItem)) ei = (PaletteItem*)tmpo;
  766.                     else if(tmpo->IsKindOf(Button)){
  767.                         button =(Button*)tmpo;
  768.                         ei = (PaletteItem*)((Button*)tmpo)->At(0);
  769.                         if(ei && ei->IsKindOf(PaletteItem)){}
  770.                         else ei=0;
  771.                     }
  772.                 }
  773.                 if(ei) 
  774.                     ei->Init(elt,gPaletteItemSize);
  775.                 else {
  776.                     ei = new PaletteItem(elt, gPaletteItemSize); 
  777.                     button  = (Button*)new PaletteButton(cIdNone,ei);
  778.                 }
  779.                 tools->Add(button);
  780.             }
  781.         }
  782.     view->AddToToolList(tools);
  783.     palette->SetCollection(tools,FALSE);
  784.  
  785.     Iter next2(tools);
  786.     while(tmpo = (VObject*) next2())
  787.         maxp = Max(maxp,tmpo->GetMinSize().extent);
  788.  
  789.     palette->SetMinExtent(maxp);
  790.     maxp+=gPoint1;
  791.  
  792.     int rows,cols;
  793.     rows  = gPaletteDocumentRows;
  794.     cols  = gPaletteDocumentCols;
  795.     int size = tools->Size();
  796.     if(gPaletteDocumentSquare && size != 0){
  797.         rows =0;
  798.         cols = Math::Sqrt(size);
  799.         if(cols ==0) cols = 1;
  800.     }
  801.  
  802.     palette->SetColsRows(Point(cols,rows));
  803.     if(rows !=0)    
  804.         maxp.y = maxp.y*rows;
  805.     else if(cols !=0)        
  806.         maxp.x = maxp.x*cols;
  807. //    Point oldmin;
  808. //    Clipper *paletteClipper=0;
  809. //    if(paletteWrapper->IsKindOf(Scroller))
  810. //        paletteClipper = ((Scroller*)paletteWrapper)->GetClipper();
  811. //    else if(paletteWrapper->IsKindOf(Clipper))
  812. //        paletteClipper = (Clipper*)paletteWrapper;
  813. //
  814. //    if(paletteClipper){
  815. //        Window * w = GetWindow();
  816. //        if(w) w->SetExtent(paletteClipper->contentRect.extent);
  817. //    }
  818. }
  819.  
  820.  
  821.  
  822.  
  823.